<?php
class FluxoTransferencia implements InterfaceFluxo
{
    const ERRO_AUTORIZACAO = 'Você não tem autorização suficiente para realizar esta operação neste momento.';
    
    public static function solicitar($vagaid, $lotacaoid, $parecer)
    {
        self::isAuthorized('solicitar', NULL, TRUE);
        
        if (empty($parecer)) {
    	    throw new Exception('Parecer é campo obrigatório.');
    	}   

    	global $usuario;
    	
        try {
        	pg_query(conexao::Conectar(), 'begin');
			
        	$transferencia = new Transferencia();
        	$transferencia->vagaid = $vagaid;
        	$transferencia->lotacaoid = $lotacaoid;
    		$transferencia->data = date('Y-m-d H:i:s');
    		$transferencia->operadorid = $usuario->operadorid;
			$transferencia->ativa = TRUE;
	       	$transferencia->salvar();

	       	$transferencia->inserirHistorico(Status::Transferencia_Solicitada, $parecer);
	       	
        	pg_query(conexao::Conectar(), 'commit');
        	
        	return $transferencia;
        }
        catch (Exception $e) {
            pg_query(conexao::Conectar(), 'rollback');
            throw new Exception($e->getMessage());
		}
    }
    
    public static function aprovar(Transferencia $transferencia, $parecer)
    {
        self::isAuthorized('aprovar', $transferencia, TRUE);
        
        if (empty($parecer)) {
    	    throw new Exception('Parecer é campo obrigatório.');
    	}        	
        try {
        	pg_query(conexao::Conectar(), 'begin');
        	
            $transferencia->ativa = FALSE;
	       	$transferencia->salvar();
	       	
	       	$transferencia->inserirHistorico(Status::Transferencia_Aprovada, $parecer);
	       	
	       	$vaga = new Vaga($transferencia->vagaid);
	       	$vaga->lotacaoid = $transferencia->lotacaoid;
	       	$vaga->salvar();
	       	
            pg_query(conexao::Conectar(), 'commit');
        }
        catch (Exception $e) {
            pg_query(conexao::Conectar(), 'rollback');
            throw new Exception($e->getMessage());
		}
    }
    
    public static function reprovar(Transferencia $transferencia, $parecer)
    {
        self::isAuthorized('reprovar', $transferencia, TRUE);
        
        if (empty($parecer)) {
    	    throw new Exception('Parecer é campo obrigatório.');
    	}        	
        try {
        	pg_query(conexao::Conectar(), 'begin');
        	
            $transferencia->ativa = FALSE;
	       	$transferencia->salvar();
	       	
	       	$transferencia->inserirHistorico(Status::Transferencia_Reprovada, $parecer);
	       	
	       	pg_query(conexao::Conectar(), 'commit');
        }
        catch (Exception $e) {
            pg_query(conexao::Conectar(), 'rollback');
            throw new Exception($e->getMessage());
		}
    }
    
    public static function excluir(Transferencia $transferencia, $usarTransacao = TRUE)
    {
        self::isAuthorized('excluir', $transferencia, TRUE);
        
        try {
    		if ($usarTransacao) {
				pg_query(conexao::Conectar(), "begin");
    		}
			
			$transferencia->ativa = FALSE;
	       	$transferencia->salvar();

	       	$transferencia->inserirHistorico(Status::Transferencia_Excluida);
	       	
			if ($usarTransacao) {
    	    	pg_query(conexao::Conectar(), "commit");
			}
    	}
		catch (Exception $e){
			if ($usarTransacao) {
                pg_query(conexao::Conectar(), 'rollback');
			}
			throw new Exception($e->getMessage());
		}
    }
    
    public static function excluirVarias($arrayIds)
    {
        try {
            pg_query(conexao::Conectar(), 'begin');
            
    		$arrayObjs = array();

    		foreach($arrayIds as $id){
		        $transferencia = new Transferencia($id);
		        self::excluir($transferencia, FALSE);
		    }      	

		    pg_query(conexao::Conectar(), 'commit');
    	}
		catch (Exception $e){
			pg_query(conexao::Conectar(), 'rollback');
			throw new Exception($e->getMessage());
		}
    }
    
    public static function isAuthorized($operacao, Transferencia $transferencia = NULL, $throwExceptions = FALSE)
    {
        $transferencia = ($transferencia) ? $transferencia : new Transferencia();
        
        $statusid = $transferencia->getTransferenciaHistoricoAtual()->statusid;
        
        global $pfcid, $usuario;
        
        if ($transferencia->getTableKeyValue() AND $transferencia->ativa == FALSE) {
            if ($throwExceptions) {
                throw new Exception('Não é possível realizar esta operação, pois esta transferência está inativa.');
            }
            return FALSE;
        }
        
        // Verifica se o usuário tem acesso à lotação ou à vaga
        if (!$usuario->isLotacaoPermitida($transferencia->lotacaoid) 
            AND !$usuario->isVagaPermitida($transferencia->vagaid)) {
            if ($throwExceptions) {
                $lotacao = new Lotacao($transferencia->lotacaoid);
                throw new Exception('Não é possível realizar esta operação, pois você não tem acesso à lotação ' . $lotacao->fantasia . '.');
            }
            return FALSE;
        }
        
        switch ($operacao) {
            case 'solicitar':
                if ($statusid == NULL) {
                    return TRUE;
                }
                break;                        
            
            case 'reprovar':
            case 'aprovar':
                if ($statusid == Status::Transferencia_Solicitada
                    AND $pfcid == PerfilComportamental::Orgao){
                    return TRUE;
                }
                break;
                
            case 'excluir':
                if ($statusid == Status::Transferencia_Solicitada){
                    return TRUE;
                }
                break;
        }
        
        if ($throwExceptions) {
            throw new Exception(self::ERRO_AUTORIZACAO);
        }
        return FALSE;
    }
    
    public static function getAlertsStatus($pfcid)
    {
        switch ($pfcid) {
            case PerfilComportamental::Orgao:
                return array(Status::Transferencia_Solicitada);
                break;
        }
    }
    
    public static function loadAlertsData($pfcid) 
    {
        $status = self::getAlertsStatus($pfcid);
        if ($status) {
            global $usuario;
            
            $status = TUtils::ArrayToSql($status);
            $view = new ViewTransferencia();
            $where = 'statusid IN (' . $status . ')';
            
            $contratoids = $usuario->listarContratosSQL();
            if ($contratoids) {
                $where .= ' AND contratoid in (' . $contratoids . ')';
            }
            
            $result = $view->listar(array(
            	'precondicao'=>$where, 
            	'orderBy'=>'dataregistro', 
            	'order'=>'desc'));
            
            if (pg_num_rows($result)>0) {
                return pg_fetch_all($result);
            }
        }
    }
}